package juc.blockqueue.linkedblockqueue;

/**
 * @ClassName LinkedBlockingQueue
 * @PackageName juc.blockqueue.linkedblockqueue
 * @projectName myThread
 * @Description LinkedBlockingQueue 使用说明
 * @Author games
 * @Date 2025/9/4 上午11:20
 * @Version 1.0
 */

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * LinkedBlockingQueue 使用说明
 * LinkedBlockingQueue 是一个基于链表实现的可选有界阻塞队列，它是 java.util.concurrent 包中的重要组件。
 * 基本特性
 * 底层实现：基于链表结构，每个节点包含数据和指向下一个节点的引用
 * 容量特性：
 * 可以指定容量（有界队列）
 * 不指定容量时默认为 Integer.MAX_VALUE（近似无界队列）
 * 线程安全：使用两个独立的锁（takeLock 和 putLock）分别控制读写操作
 * 阻塞特性：当队列为空时读取阻塞，当队列满时写入阻塞
 *
 *
 * 插入操作
 * put(E e)：在队尾插入元素，队列满时阻塞
 * offer(E e)：在队尾插入元素，立即返回 true/false
 * offer(E e, long timeout, TimeUnit unit)：在队尾插入元素，可设置超时时间
 * 移除操作
 * take()：从队首移除并返回元素，队列空时阻塞
 * poll()：从队首移除并返回元素，立即返回元素或 null
 * poll(long timeout, TimeUnit unit)：从队首移除并返回元素，可设置超时时间
 * 检查操作
 * peek()：返回队首元素但不移除，队列空时返回 null
 * size()：返回队列中元素数量
 * remainingCapacity()：返回队列剩余容量
 */
public class LinkedBlockingQueueExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

        // 生产者线程
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Consumed: " + queue.take());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producer.start();
        consumer.start();
    }
}
